home *** CD-ROM | disk | FTP | other *** search
/ PC PowerPlay 58 / pcpp58a.iso / extras / quake 3 source / Q3A_ToolSource.exe / Main / imagelib.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-01-02  |  23.9 KB  |  1,144 lines
  1. // imagelib.c
  2.  
  3. #include "cmdlib.h"
  4. #include "imagelib.h"
  5.  
  6.  
  7. int fgetLittleShort (FILE *f)
  8. {
  9.     byte    b1, b2;
  10.  
  11.     b1 = fgetc(f);
  12.     b2 = fgetc(f);
  13.  
  14.     return (short)(b1 + b2*256);
  15. }
  16.  
  17. int fgetLittleLong (FILE *f)
  18. {
  19.     byte    b1, b2, b3, b4;
  20.  
  21.     b1 = fgetc(f);
  22.     b2 = fgetc(f);
  23.     b3 = fgetc(f);
  24.     b4 = fgetc(f);
  25.  
  26.     return b1 + (b2<<8) + (b3<<16) + (b4<<24);
  27. }
  28.  
  29.  
  30.  
  31. /*
  32. ============================================================================
  33.  
  34.                         LBM STUFF
  35.  
  36. ============================================================================
  37. */
  38.  
  39.  
  40. typedef unsigned char    UBYTE;
  41. //conflicts with windows typedef short            WORD;
  42. typedef unsigned short    UWORD;
  43. typedef long            LONG;
  44.  
  45. typedef enum
  46. {
  47.     ms_none,
  48.     ms_mask,
  49.     ms_transcolor,
  50.     ms_lasso
  51. } mask_t;
  52.  
  53. typedef enum
  54. {
  55.     cm_none,
  56.     cm_rle1
  57. } compress_t;
  58.  
  59. typedef struct
  60. {
  61.     UWORD        w,h;
  62.     short        x,y;
  63.     UBYTE        nPlanes;
  64.     UBYTE        masking;
  65.     UBYTE        compression;
  66.     UBYTE        pad1;
  67.     UWORD        transparentColor;
  68.     UBYTE        xAspect,yAspect;
  69.     short        pageWidth,pageHeight;
  70. } bmhd_t;
  71.  
  72. extern    bmhd_t    bmhd;                        // will be in native byte order
  73.  
  74.  
  75.  
  76. #define FORMID ('F'+('O'<<8)+((int)'R'<<16)+((int)'M'<<24))
  77. #define ILBMID ('I'+('L'<<8)+((int)'B'<<16)+((int)'M'<<24))
  78. #define PBMID  ('P'+('B'<<8)+((int)'M'<<16)+((int)' '<<24))
  79. #define BMHDID ('B'+('M'<<8)+((int)'H'<<16)+((int)'D'<<24))
  80. #define BODYID ('B'+('O'<<8)+((int)'D'<<16)+((int)'Y'<<24))
  81. #define CMAPID ('C'+('M'<<8)+((int)'A'<<16)+((int)'P'<<24))
  82.  
  83.  
  84. bmhd_t  bmhd;
  85.  
  86. int    Align (int l)
  87. {
  88.     if (l&1)
  89.         return l+1;
  90.     return l;
  91. }
  92.  
  93.  
  94.  
  95. /*
  96. ================
  97. LBMRLEdecompress
  98.  
  99. Source must be evenly aligned!
  100. ================
  101. */
  102. byte  *LBMRLEDecompress (byte *source,byte *unpacked, int bpwidth)
  103. {
  104.     int     count;
  105.     byte    b,rept;
  106.  
  107.     count = 0;
  108.  
  109.     do
  110.     {
  111.         rept = *source++;
  112.  
  113.         if (rept > 0x80)
  114.         {
  115.             rept = (rept^0xff)+2;
  116.             b = *source++;
  117.             memset(unpacked,b,rept);
  118.             unpacked += rept;
  119.         }
  120.         else if (rept < 0x80)
  121.         {
  122.             rept++;
  123.             memcpy(unpacked,source,rept);
  124.             unpacked += rept;
  125.             source += rept;
  126.         }
  127.         else
  128.             rept = 0;               // rept of 0x80 is NOP
  129.  
  130.         count += rept;
  131.  
  132.     } while (count<bpwidth);
  133.  
  134.     if (count>bpwidth)
  135.         Error ("Decompression exceeded width!\n");
  136.  
  137.  
  138.     return source;
  139. }
  140.  
  141.  
  142. /*
  143. =================
  144. LoadLBM
  145. =================
  146. */
  147. void LoadLBM (const char *filename, byte **picture, byte **palette)
  148. {
  149.     byte    *LBMbuffer, *picbuffer, *cmapbuffer;
  150.     int             y;
  151.     byte    *LBM_P, *LBMEND_P;
  152.     byte    *pic_p;
  153.     byte    *body_p;
  154.  
  155.     int    formtype,formlength;
  156.     int    chunktype,chunklength;
  157.  
  158. // qiet compiler warnings
  159.     picbuffer = NULL;
  160.     cmapbuffer = NULL;
  161.  
  162. //
  163. // load the LBM
  164. //
  165.     LoadFile (filename, (void **)&LBMbuffer);
  166.  
  167. //
  168. // parse the LBM header
  169. //
  170.     LBM_P = LBMbuffer;
  171.     if ( *(int *)LBMbuffer != LittleLong(FORMID) )
  172.        Error ("No FORM ID at start of file!\n");
  173.  
  174.     LBM_P += 4;
  175.     formlength = BigLong( *(int *)LBM_P );
  176.     LBM_P += 4;
  177.     LBMEND_P = LBM_P + Align(formlength);
  178.  
  179.     formtype = LittleLong(*(int *)LBM_P);
  180.  
  181.     if (formtype != ILBMID && formtype != PBMID)
  182.         Error ("Unrecognized form type: %c%c%c%c\n", formtype&0xff
  183.         ,(formtype>>8)&0xff,(formtype>>16)&0xff,(formtype>>24)&0xff);
  184.  
  185.     LBM_P += 4;
  186.  
  187. //
  188. // parse chunks
  189. //
  190.  
  191.     while (LBM_P < LBMEND_P)
  192.     {
  193.         chunktype = LBM_P[0] + (LBM_P[1]<<8) + (LBM_P[2]<<16) + (LBM_P[3]<<24);
  194.         LBM_P += 4;
  195.         chunklength = LBM_P[3] + (LBM_P[2]<<8) + (LBM_P[1]<<16) + (LBM_P[0]<<24);
  196.         LBM_P += 4;
  197.  
  198.         switch ( chunktype )
  199.         {
  200.         case BMHDID:
  201.             memcpy (&bmhd,LBM_P,sizeof(bmhd));
  202.             bmhd.w = BigShort(bmhd.w);
  203.             bmhd.h = BigShort(bmhd.h);
  204.             bmhd.x = BigShort(bmhd.x);
  205.             bmhd.y = BigShort(bmhd.y);
  206.             bmhd.pageWidth = BigShort(bmhd.pageWidth);
  207.             bmhd.pageHeight = BigShort(bmhd.pageHeight);
  208.             break;
  209.  
  210.         case CMAPID:
  211.             cmapbuffer = malloc (768);
  212.             memset (cmapbuffer, 0, 768);
  213.             memcpy (cmapbuffer, LBM_P, chunklength);
  214.             break;
  215.  
  216.         case BODYID:
  217.             body_p = LBM_P;
  218.  
  219.             pic_p = picbuffer = malloc (bmhd.w*bmhd.h);
  220.             if (formtype == PBMID)
  221.             {
  222.             //
  223.             // unpack PBM
  224.             //
  225.                 for (y=0 ; y<bmhd.h ; y++, pic_p += bmhd.w)
  226.                 {
  227.                     if (bmhd.compression == cm_rle1)
  228.                         body_p = LBMRLEDecompress ((byte *)body_p
  229.                         , pic_p , bmhd.w);
  230.                     else if (bmhd.compression == cm_none)
  231.                     {
  232.                         memcpy (pic_p,body_p,bmhd.w);
  233.                         body_p += Align(bmhd.w);
  234.                     }
  235.                 }
  236.  
  237.             }
  238.             else
  239.             {
  240.             //
  241.             // unpack ILBM
  242.             //
  243.                 Error ("%s is an interlaced LBM, not packed", filename);
  244.             }
  245.             break;
  246.         }
  247.  
  248.         LBM_P += Align(chunklength);
  249.     }
  250.  
  251.     free (LBMbuffer);
  252.  
  253.     *picture = picbuffer;
  254.  
  255.     if (palette)
  256.         *palette = cmapbuffer;
  257. }
  258.  
  259.  
  260. /*
  261. ============================================================================
  262.  
  263.                             WRITE LBM
  264.  
  265. ============================================================================
  266. */
  267.  
  268. /*
  269. ==============
  270. WriteLBMfile
  271. ==============
  272. */
  273. void WriteLBMfile (const char *filename, byte *data,
  274.                    int width, int height, byte *palette)
  275. {
  276.     byte    *lbm, *lbmptr;
  277.     int    *formlength, *bmhdlength, *cmaplength, *bodylength;
  278.     int    length;
  279.     bmhd_t  basebmhd;
  280.  
  281.     lbm = lbmptr = malloc (width*height+1000);
  282.  
  283. //
  284. // start FORM
  285. //
  286.     *lbmptr++ = 'F';
  287.     *lbmptr++ = 'O';
  288.     *lbmptr++ = 'R';
  289.     *lbmptr++ = 'M';
  290.  
  291.     formlength = (int*)lbmptr;
  292.     lbmptr+=4;                      // leave space for length
  293.  
  294.     *lbmptr++ = 'P';
  295.     *lbmptr++ = 'B';
  296.     *lbmptr++ = 'M';
  297.     *lbmptr++ = ' ';
  298.  
  299. //
  300. // write BMHD
  301. //
  302.     *lbmptr++ = 'B';
  303.     *lbmptr++ = 'M';
  304.     *lbmptr++ = 'H';
  305.     *lbmptr++ = 'D';
  306.  
  307.     bmhdlength = (int *)lbmptr;
  308.     lbmptr+=4;                      // leave space for length
  309.  
  310.     memset (&basebmhd,0,sizeof(basebmhd));
  311.     basebmhd.w = BigShort((short)width);
  312.     basebmhd.h = BigShort((short)height);
  313.     basebmhd.nPlanes = BigShort(8);
  314.     basebmhd.xAspect = BigShort(5);
  315.     basebmhd.yAspect = BigShort(6);
  316.     basebmhd.pageWidth = BigShort((short)width);
  317.     basebmhd.pageHeight = BigShort((short)height);
  318.  
  319.     memcpy (lbmptr,&basebmhd,sizeof(basebmhd));
  320.     lbmptr += sizeof(basebmhd);
  321.  
  322.     length = lbmptr-(byte *)bmhdlength-4;
  323.     *bmhdlength = BigLong(length);
  324.     if (length&1)
  325.         *lbmptr++ = 0;          // pad chunk to even offset
  326.  
  327. //
  328. // write CMAP
  329. //
  330.     *lbmptr++ = 'C';
  331.     *lbmptr++ = 'M';
  332.     *lbmptr++ = 'A';
  333.     *lbmptr++ = 'P';
  334.  
  335.     cmaplength = (int *)lbmptr;
  336.     lbmptr+=4;                      // leave space for length
  337.  
  338.     memcpy (lbmptr,palette,768);
  339.     lbmptr += 768;
  340.  
  341.     length = lbmptr-(byte *)cmaplength-4;
  342.     *cmaplength = BigLong(length);
  343.     if (length&1)
  344.         *lbmptr++ = 0;          // pad chunk to even offset
  345.  
  346. //
  347. // write BODY
  348. //
  349.     *lbmptr++ = 'B';
  350.     *lbmptr++ = 'O';
  351.     *lbmptr++ = 'D';
  352.     *lbmptr++ = 'Y';
  353.  
  354.     bodylength = (int *)lbmptr;
  355.     lbmptr+=4;                      // leave space for length
  356.  
  357.     memcpy (lbmptr,data,width*height);
  358.     lbmptr += width*height;
  359.  
  360.     length = lbmptr-(byte *)bodylength-4;
  361.     *bodylength = BigLong(length);
  362.     if (length&1)
  363.         *lbmptr++ = 0;          // pad chunk to even offset
  364.  
  365. //
  366. // done
  367. //
  368.     length = lbmptr-(byte *)formlength-4;
  369.     *formlength = BigLong(length);
  370.     if (length&1)
  371.         *lbmptr++ = 0;          // pad chunk to even offset
  372.  
  373. //
  374. // write output file
  375. //
  376.     SaveFile (filename, lbm, lbmptr-lbm);
  377.     free (lbm);
  378. }
  379.  
  380.  
  381. /*
  382. ============================================================================
  383.  
  384. LOAD PCX
  385.  
  386. ============================================================================
  387. */
  388.  
  389. typedef struct
  390. {
  391.     char    manufacturer;
  392.     char    version;
  393.     char    encoding;
  394.     char    bits_per_pixel;
  395.     unsigned short    xmin,ymin,xmax,ymax;
  396.     unsigned short    hres,vres;
  397.     unsigned char    palette[48];
  398.     char    reserved;
  399.     char    color_planes;
  400.     unsigned short    bytes_per_line;
  401.     unsigned short    palette_type;
  402.     char    filler[58];
  403.     unsigned char    data;            // unbounded
  404. } pcx_t;
  405.  
  406.  
  407. /*
  408. ==============
  409. LoadPCX
  410. ==============
  411. */
  412. void LoadPCX (const char *filename, byte **pic, byte **palette, int *width, int *height)
  413. {
  414.     byte    *raw;
  415.     pcx_t    *pcx;
  416.     int        x, y;
  417.     int        len;
  418.     int        dataByte, runLength;
  419.     byte    *out, *pix;
  420.  
  421.     //
  422.     // load the file
  423.     //
  424.     len = LoadFile (filename, (void **)&raw);
  425.  
  426.     //
  427.     // parse the PCX file
  428.     //
  429.     pcx = (pcx_t *)raw;
  430.     raw = &pcx->data;
  431.  
  432.     pcx->xmin = LittleShort(pcx->xmin);
  433.     pcx->ymin = LittleShort(pcx->ymin);
  434.     pcx->xmax = LittleShort(pcx->xmax);
  435.     pcx->ymax = LittleShort(pcx->ymax);
  436.     pcx->hres = LittleShort(pcx->hres);
  437.     pcx->vres = LittleShort(pcx->vres);
  438.     pcx->bytes_per_line = LittleShort(pcx->bytes_per_line);
  439.     pcx->palette_type = LittleShort(pcx->palette_type);
  440.  
  441.     if (pcx->manufacturer != 0x0a
  442.         || pcx->version != 5
  443.         || pcx->encoding != 1
  444.         || pcx->bits_per_pixel != 8
  445.         || pcx->xmax >= 640
  446.         || pcx->ymax >= 480)
  447.         Error ("Bad pcx file %s", filename);
  448.     
  449.     if (palette)
  450.     {
  451.         *palette = malloc(768);
  452.         memcpy (*palette, (byte *)pcx + len - 768, 768);
  453.     }
  454.  
  455.     if (width)
  456.         *width = pcx->xmax+1;
  457.     if (height)
  458.         *height = pcx->ymax+1;
  459.  
  460.     if (!pic)
  461.         return;
  462.  
  463.     out = malloc ( (pcx->ymax+1) * (pcx->xmax+1) );
  464.     if (!out)
  465.         Error ("Skin_Cache: couldn't allocate");
  466.  
  467.     *pic = out;
  468.  
  469.     pix = out;
  470.  
  471.     for (y=0 ; y<=pcx->ymax ; y++, pix += pcx->xmax+1)
  472.     {
  473.         for (x=0 ; x<=pcx->xmax ; )
  474.         {
  475.             dataByte = *raw++;
  476.  
  477.             if((dataByte & 0xC0) == 0xC0)
  478.             {
  479.                 runLength = dataByte & 0x3F;
  480.                 dataByte = *raw++;
  481.             }
  482.             else
  483.                 runLength = 1;
  484.  
  485.             // FIXME: this shouldn't happen, but it does.  Are we decoding the file wrong?
  486.             // Truncate runLength so we don't overrun the end of the buffer
  487.             if ( ( y == pcx->ymax ) && ( x + runLength > pcx->xmax + 1 ) ) {
  488.                 runLength = pcx->xmax - x + 1;
  489.             }
  490.  
  491.             while(runLength-- > 0)
  492.                 pix[x++] = dataByte;
  493.         }
  494.  
  495.     }
  496.  
  497.     if ( raw - (byte *)pcx > len)
  498.         Error ("PCX file %s was malformed", filename);
  499.  
  500.     free (pcx);
  501. }
  502.  
  503. /* 
  504. ============== 
  505. WritePCXfile 
  506. ============== 
  507. */ 
  508. void WritePCXfile (const char *filename, byte *data, 
  509.                    int width, int height, byte *palette) 
  510. {
  511.     int        i, j, length;
  512.     pcx_t    *pcx;
  513.     byte        *pack;
  514.       
  515.     pcx = malloc (width*height*2+1000);
  516.     memset (pcx, 0, sizeof(*pcx));
  517.  
  518.     pcx->manufacturer = 0x0a;    // PCX id
  519.     pcx->version = 5;            // 256 color
  520.      pcx->encoding = 1;        // uncompressed
  521.     pcx->bits_per_pixel = 8;        // 256 color
  522.     pcx->xmin = 0;
  523.     pcx->ymin = 0;
  524.     pcx->xmax = LittleShort((short)(width-1));
  525.     pcx->ymax = LittleShort((short)(height-1));
  526.     pcx->hres = LittleShort((short)width);
  527.     pcx->vres = LittleShort((short)height);
  528.     pcx->color_planes = 1;        // chunky image
  529.     pcx->bytes_per_line = LittleShort((short)width);
  530.     pcx->palette_type = LittleShort(1);        // not a grey scale
  531.  
  532.     // pack the image
  533.     pack = &pcx->data;
  534.     
  535.     for (i=0 ; i<height ; i++)
  536.     {
  537.         for (j=0 ; j<width ; j++)
  538.         {
  539.             if ( (*data & 0xc0) != 0xc0)
  540.                 *pack++ = *data++;
  541.             else
  542.             {
  543.                 *pack++ = 0xc1;
  544.                 *pack++ = *data++;
  545.             }
  546.         }
  547.     }
  548.             
  549.     // write the palette
  550.     *pack++ = 0x0c;    // palette ID byte
  551.     for (i=0 ; i<768 ; i++)
  552.         *pack++ = *palette++;
  553.         
  554. // write output file 
  555.     length = pack - (byte *)pcx;
  556.     SaveFile (filename, pcx, length);
  557.  
  558.     free (pcx);
  559. } 
  560.  
  561. /*
  562. ============================================================================
  563.  
  564. LOAD BMP
  565.  
  566. ============================================================================
  567. */
  568.  
  569.  
  570. /*
  571.  
  572. // we can't just use these structures, because
  573. // compiler structure alignment will not be portable
  574. // on this unaligned stuff
  575.  
  576. typedef struct tagBITMAPFILEHEADER { // bmfh 
  577.         WORD    bfType;                // BM
  578.         DWORD   bfSize; 
  579.         WORD    bfReserved1; 
  580.         WORD    bfReserved2; 
  581.         DWORD   bfOffBits; 
  582. } BITMAPFILEHEADER; 
  583.  
  584. typedef struct tagBITMAPINFOHEADER{ // bmih 
  585.    DWORD  biSize; 
  586.    LONG   biWidth; 
  587.    LONG   biHeight; 
  588.    WORD   biPlanes; 
  589.    WORD   biBitCount 
  590.    DWORD  biCompression; 
  591.    DWORD  biSizeImage; 
  592.    LONG   biXPelsPerMeter; 
  593.    LONG   biYPelsPerMeter; 
  594.    DWORD  biClrUsed; 
  595.    DWORD  biClrImportant; 
  596. } BITMAPINFOHEADER; 
  597.  
  598. typedef struct tagBITMAPINFO { // bmi 
  599.    BITMAPINFOHEADER bmiHeader; 
  600.    RGBQUAD          bmiColors[1]; 
  601. } BITMAPINFO; 
  602.  
  603. typedef struct tagBITMAPCOREHEADER { // bmch 
  604.         DWORD   bcSize; 
  605.         WORD    bcWidth; 
  606.         WORD    bcHeight; 
  607.         WORD    bcPlanes; 
  608.         WORD    bcBitCount; 
  609. } BITMAPCOREHEADER; 
  610.  
  611. typedef struct _BITMAPCOREINFO {    // bmci 
  612.         BITMAPCOREHEADER  bmciHeader; 
  613.         RGBTRIPLE         bmciColors[1]; 
  614. } BITMAPCOREINFO; 
  615.  
  616. */
  617.  
  618. /*
  619. ==============
  620. LoadBMP
  621. ==============
  622. */
  623. void LoadBMP (const char *filename, byte **pic, byte **palette, int *width, int *height)
  624. {
  625.     byte    *out;
  626.     FILE    *fin;
  627.     int        i;
  628.     int        bfSize; 
  629.     int        bfOffBits; 
  630.     int        structSize;
  631.     int        bcWidth; 
  632.     int     bcHeight; 
  633.     int        bcPlanes; 
  634.     int        bcBitCount; 
  635.     byte    bcPalette[1024];
  636.     qboolean    flipped;
  637.  
  638.     fin = fopen (filename, "rb");
  639.     if (!fin) {
  640.         Error ("Couldn't read %s", filename);
  641.     }
  642.  
  643.     i = fgetLittleShort (fin);
  644.     if (i != 'B' + ('M'<<8) ) {
  645.         Error ("%s is not a bmp file", filename);
  646.     }
  647.  
  648.     bfSize = fgetLittleLong (fin);
  649.     fgetLittleShort(fin);
  650.     fgetLittleShort(fin);
  651.     bfOffBits = fgetLittleLong (fin);
  652.  
  653.     // the size will tell us if it is a
  654.     // bitmapinfo or a bitmapcore
  655.     structSize = fgetLittleLong (fin);
  656.     if (structSize == 40) {
  657.         // bitmapinfo
  658.         bcWidth = fgetLittleLong(fin); 
  659.         bcHeight= fgetLittleLong(fin); 
  660.         bcPlanes = fgetLittleShort(fin); 
  661.         bcBitCount = fgetLittleShort(fin); 
  662.  
  663.         fseek (fin, 24, SEEK_CUR);
  664.  
  665.         if (palette) {
  666.             fread (bcPalette, 1, 1024, fin);
  667.             *palette = malloc(768);
  668.  
  669.             for (i = 0 ; i < 256 ; i++) {
  670.                 (*palette)[i * 3 + 0] = bcPalette[i * 4 + 2];
  671.                 (*palette)[i * 3 + 1] = bcPalette[i * 4 + 1];
  672.                 (*palette)[i * 3 + 2] = bcPalette[i * 4 + 0];
  673.             }
  674.         }
  675.     } else if (structSize == 12) {
  676.         // bitmapcore
  677.         bcWidth = fgetLittleShort(fin); 
  678.         bcHeight= fgetLittleShort(fin); 
  679.         bcPlanes = fgetLittleShort(fin); 
  680.         bcBitCount = fgetLittleShort(fin); 
  681.  
  682.         if (palette) {
  683.             fread (bcPalette, 1, 768, fin);
  684.             *palette = malloc(768);
  685.  
  686.             for (i = 0 ; i < 256 ; i++) {
  687.                 (*palette)[i * 3 + 0] = bcPalette[i * 3 + 2];
  688.                 (*palette)[i * 3 + 1] = bcPalette[i * 3 + 1];
  689.                 (*palette)[i * 3 + 2] = bcPalette[i * 3 + 0];
  690.             }
  691.         }
  692.     } else {
  693.         Error ("%s had strange struct size", filename);
  694.     }
  695.     
  696.     if (bcPlanes != 1) {
  697.         Error ("%s was not a single plane image", filename);
  698.     }
  699.  
  700.     if (bcBitCount != 8) {
  701.         Error ("%s was not an 8 bit image", filename);
  702.     }
  703.  
  704.     if (bcHeight < 0) {
  705.         bcHeight = -bcHeight;
  706.         flipped = qtrue;
  707.     } else {
  708.         flipped = qfalse;
  709.     }
  710.  
  711.     if (width)
  712.         *width = bcWidth;
  713.     if (height)
  714.         *height = bcHeight;
  715.  
  716.     if (!pic) {
  717.         fclose (fin);
  718.         return;
  719.     }
  720.  
  721.     out = malloc ( bcWidth * bcHeight );
  722.     *pic = out;
  723.     fseek (fin, bfOffBits, SEEK_SET);
  724.  
  725.     if (flipped) {
  726.         for (i = 0 ; i < bcHeight ; i++) {
  727.             fread (out + bcWidth * (bcHeight - 1 - i), 1, bcWidth, fin);
  728.         }
  729.     } else {
  730.         fread (out, 1, bcWidth*bcHeight, fin);
  731.     }
  732.  
  733.     fclose (fin);
  734. }
  735.  
  736.  
  737. /*
  738. ============================================================================
  739.  
  740. LOAD IMAGE
  741.  
  742. ============================================================================
  743. */
  744.  
  745. /*
  746. ==============
  747. Load256Image
  748.  
  749. Will load either an lbm or pcx, depending on extension.
  750. Any of the return pointers can be NULL if you don't want them.
  751. ==============
  752. */
  753. void Load256Image (const char *name, byte **pixels, byte **palette,
  754.                    int *width, int *height)
  755. {
  756.     char    ext[128];
  757.  
  758.     ExtractFileExtension (name, ext);
  759.     if (!Q_stricmp (ext, "lbm"))
  760.     {
  761.         LoadLBM (name, pixels, palette);
  762.         if (width)
  763.             *width = bmhd.w;
  764.         if (height)
  765.             *height = bmhd.h;
  766.     }
  767.     else if (!Q_stricmp (ext, "pcx"))
  768.     {
  769.         LoadPCX (name, pixels, palette, width, height);
  770.     }
  771.     else if (!Q_stricmp (ext, "bmp"))
  772.     {
  773.         LoadBMP (name, pixels, palette, width, height);
  774.     }
  775.     else
  776.         Error ("%s doesn't have a known image extension", name);
  777. }
  778.  
  779.  
  780. /*
  781. ==============
  782. Save256Image
  783.  
  784. Will save either an lbm or pcx, depending on extension.
  785. ==============
  786. */
  787. void Save256Image (const char *name, byte *pixels, byte *palette,
  788.                    int width, int height)
  789. {
  790.     char    ext[128];
  791.  
  792.     ExtractFileExtension (name, ext);
  793.     if (!Q_stricmp (ext, "lbm"))
  794.     {
  795.         WriteLBMfile (name, pixels, width, height, palette);
  796.     }
  797.     else if (!Q_stricmp (ext, "pcx"))
  798.     {
  799.         WritePCXfile (name, pixels, width, height, palette);
  800.     }
  801.     else
  802.         Error ("%s doesn't have a known image extension", name);
  803. }
  804.  
  805.  
  806.  
  807.  
  808. /*
  809. ============================================================================
  810.  
  811. TARGA IMAGE
  812.  
  813. ============================================================================
  814. */
  815.  
  816. typedef struct _TargaHeader {
  817.     unsigned char     id_length, colormap_type, image_type;
  818.     unsigned short    colormap_index, colormap_length;
  819.     unsigned char    colormap_size;
  820.     unsigned short    x_origin, y_origin, width, height;
  821.     unsigned char    pixel_size, attributes;
  822. } TargaHeader;
  823.  
  824. /*
  825. =============
  826. LoadTGABuffer
  827. =============
  828. */
  829. void LoadTGABuffer ( byte *buffer, byte **pic, int *width, int *height)
  830. {
  831.     int        columns, rows, numPixels;
  832.     byte    *pixbuf;
  833.     int        row, column;
  834.     byte    *buf_p;
  835.     TargaHeader    targa_header;
  836.     byte        *targa_rgba;
  837.  
  838.     *pic = NULL;
  839.  
  840.     buf_p = buffer;
  841.  
  842.     targa_header.id_length = *buf_p++;
  843.     targa_header.colormap_type = *buf_p++;
  844.     targa_header.image_type = *buf_p++;
  845.     
  846.     targa_header.colormap_index = LittleShort ( *(short *)buf_p );
  847.     buf_p += 2;
  848.     targa_header.colormap_length = LittleShort ( *(short *)buf_p );
  849.     buf_p += 2;
  850.     targa_header.colormap_size = *buf_p++;
  851.     targa_header.x_origin = LittleShort ( *(short *)buf_p );
  852.     buf_p += 2;
  853.     targa_header.y_origin = LittleShort ( *(short *)buf_p );
  854.     buf_p += 2;
  855.     targa_header.width = LittleShort ( *(short *)buf_p );
  856.     buf_p += 2;
  857.     targa_header.height = LittleShort ( *(short *)buf_p );
  858.     buf_p += 2;
  859.     targa_header.pixel_size = *buf_p++;
  860.     targa_header.attributes = *buf_p++;
  861.  
  862.     if (targa_header.image_type!=2 
  863.         && targa_header.image_type!=10
  864.         && targa_header.image_type != 3 ) 
  865.     {
  866.         Error("LoadTGA: Only type 2 (RGB), 3 (gray), and 10 (RGB) TGA images supported\n");
  867.     }
  868.  
  869.     if ( targa_header.colormap_type != 0 )
  870.     {
  871.         Error("LoadTGA: colormaps not supported\n" );
  872.     }
  873.  
  874.     if ( ( targa_header.pixel_size != 32 && targa_header.pixel_size != 24 ) && targa_header.image_type != 3 )
  875.     {
  876.         Error("LoadTGA: Only 32 or 24 bit images supported (no colormaps)\n");
  877.     }
  878.  
  879.     columns = targa_header.width;
  880.     rows = targa_header.height;
  881.     numPixels = columns * rows;
  882.  
  883.     if (width)
  884.         *width = columns;
  885.     if (height)
  886.         *height = rows;
  887.  
  888.     targa_rgba = malloc (numPixels*4);
  889.     *pic = targa_rgba;
  890.  
  891.     if (targa_header.id_length != 0)
  892.         buf_p += targa_header.id_length;  // skip TARGA image comment
  893.     
  894.     if ( targa_header.image_type==2 || targa_header.image_type == 3 )
  895.     { 
  896.         // Uncompressed RGB or gray scale image
  897.         for(row=rows-1; row>=0; row--) 
  898.         {
  899.             pixbuf = targa_rgba + row*columns*4;
  900.             for(column=0; column<columns; column++) 
  901.             {
  902.                 unsigned char red,green,blue,alphabyte;
  903.                 switch (targa_header.pixel_size) 
  904.                 {
  905.                     
  906.                 case 8:
  907.                     blue = *buf_p++;
  908.                     green = blue;
  909.                     red = blue;
  910.                     *pixbuf++ = red;
  911.                     *pixbuf++ = green;
  912.                     *pixbuf++ = blue;
  913.                     *pixbuf++ = 255;
  914.                     break;
  915.  
  916.                 case 24:
  917.                     blue = *buf_p++;
  918.                     green = *buf_p++;
  919.                     red = *buf_p++;
  920.                     *pixbuf++ = red;
  921.                     *pixbuf++ = green;
  922.                     *pixbuf++ = blue;
  923.                     *pixbuf++ = 255;
  924.                     break;
  925.                 case 32:
  926.                     blue = *buf_p++;
  927.                     green = *buf_p++;
  928.                     red = *buf_p++;
  929.                     alphabyte = *buf_p++;
  930.                     *pixbuf++ = red;
  931.                     *pixbuf++ = green;
  932.                     *pixbuf++ = blue;
  933.                     *pixbuf++ = alphabyte;
  934.                     break;
  935.                 default:
  936.                     //Error("LoadTGA: illegal pixel_size '%d' in file '%s'\n", targa_header.pixel_size, name );
  937.                     break;
  938.                 }
  939.             }
  940.         }
  941.     }
  942.     else if (targa_header.image_type==10) {   // Runlength encoded RGB images
  943.         unsigned char red,green,blue,alphabyte,packetHeader,packetSize,j;
  944.  
  945.         red = 0;
  946.         green = 0;
  947.         blue = 0;
  948.         alphabyte = 0xff;
  949.  
  950.         for(row=rows-1; row>=0; row--) {
  951.             pixbuf = targa_rgba + row*columns*4;
  952.             for(column=0; column<columns; ) {
  953.                 packetHeader= *buf_p++;
  954.                 packetSize = 1 + (packetHeader & 0x7f);
  955.                 if (packetHeader & 0x80) {        // run-length packet
  956.                     switch (targa_header.pixel_size) {
  957.                         case 24:
  958.                                 blue = *buf_p++;
  959.                                 green = *buf_p++;
  960.                                 red = *buf_p++;
  961.                                 alphabyte = 255;
  962.                                 break;
  963.                         case 32:
  964.                                 blue = *buf_p++;
  965.                                 green = *buf_p++;
  966.                                 red = *buf_p++;
  967.                                 alphabyte = *buf_p++;
  968.                                 break;
  969.                         default:
  970.                             //Error("LoadTGA: illegal pixel_size '%d' in file '%s'\n", targa_header.pixel_size, name );
  971.                             break;
  972.                     }
  973.     
  974.                     for(j=0;j<packetSize;j++) {
  975.                         *pixbuf++=red;
  976.                         *pixbuf++=green;
  977.                         *pixbuf++=blue;
  978.                         *pixbuf++=alphabyte;
  979.                         column++;
  980.                         if (column==columns) { // run spans across rows
  981.                             column=0;
  982.                             if (row>0)
  983.                                 row--;
  984.                             else
  985.                                 goto breakOut;
  986.                             pixbuf = targa_rgba + row*columns*4;
  987.                         }
  988.                     }
  989.                 }
  990.                 else {                            // non run-length packet
  991.                     for(j=0;j<packetSize;j++) {
  992.                         switch (targa_header.pixel_size) {
  993.                             case 24:
  994.                                     blue = *buf_p++;
  995.                                     green = *buf_p++;
  996.                                     red = *buf_p++;
  997.                                     *pixbuf++ = red;
  998.                                     *pixbuf++ = green;
  999.                                     *pixbuf++ = blue;
  1000.                                     *pixbuf++ = 255;
  1001.                                     break;
  1002.                             case 32:
  1003.                                     blue = *buf_p++;
  1004.                                     green = *buf_p++;
  1005.                                     red = *buf_p++;
  1006.                                     alphabyte = *buf_p++;
  1007.                                     *pixbuf++ = red;
  1008.                                     *pixbuf++ = green;
  1009.                                     *pixbuf++ = blue;
  1010.                                     *pixbuf++ = alphabyte;
  1011.                                     break;
  1012.                             default:
  1013.                                 //Sys_Printf("LoadTGA: illegal pixel_size '%d' in file '%s'\n", targa_header.pixel_size, name );
  1014.                                 break;
  1015.                         }
  1016.                         column++;
  1017.                         if (column==columns) { // pixel packet run spans across rows
  1018.                             column=0;
  1019.                             if (row>0)
  1020.                                 row--;
  1021.                             else
  1022.                                 goto breakOut;
  1023.                             pixbuf = targa_rgba + row*columns*4;
  1024.                         }                        
  1025.                     }
  1026.                 }
  1027.             }
  1028.             breakOut:;
  1029.         }
  1030.     }
  1031.  
  1032.     //free(buffer);
  1033. }
  1034.  
  1035.  
  1036.  
  1037. /*
  1038. =============
  1039. LoadTGA
  1040. =============
  1041. */
  1042. void LoadTGA (const char *name, byte **pixels, int *width, int *height)
  1043. {
  1044.     byte            *buffer;
  1045.   int nLen;
  1046.     //
  1047.     // load the file
  1048.     //
  1049.     nLen = LoadFile ( ( char * ) name, (void **)&buffer);
  1050.     if (nLen == -1) 
  1051.   {
  1052.         Error ("Couldn't read %s", name);
  1053.   }
  1054.  
  1055.   LoadTGABuffer(buffer, pixels, width, height);
  1056.  
  1057. }
  1058.  
  1059.  
  1060. /*
  1061. ================
  1062. WriteTGA
  1063. ================
  1064. */
  1065. void WriteTGA (const char *filename, byte *data, int width, int height) {
  1066.     byte    *buffer;
  1067.     int        i;
  1068.     int        c;
  1069.     FILE    *f;
  1070.  
  1071.     buffer = malloc(width*height*4 + 18);
  1072.     memset (buffer, 0, 18);
  1073.     buffer[2] = 2;        // uncompressed type
  1074.     buffer[12] = width&255;
  1075.     buffer[13] = width>>8;
  1076.     buffer[14] = height&255;
  1077.     buffer[15] = height>>8;
  1078.     buffer[16] = 32;    // pixel size
  1079.  
  1080.     // swap rgb to bgr
  1081.     c = 18 + width * height * 4;
  1082.     for (i=18 ; i<c ; i+=4)
  1083.     {
  1084.         buffer[i] = data[i-18+2];        // blue
  1085.         buffer[i+1] = data[i-18+1];        // green
  1086.         buffer[i+2] = data[i-18+0];        // red
  1087.         buffer[i+3] = data[i-18+3];        // alpha
  1088.     }
  1089.  
  1090.     f = fopen (filename, "wb");
  1091.     fwrite (buffer, 1, c, f);
  1092.     fclose (f);
  1093.  
  1094.     free (buffer);
  1095. }
  1096.  
  1097. /*
  1098. ============================================================================
  1099.  
  1100. LOAD32BITIMAGE
  1101.  
  1102. ============================================================================
  1103. */
  1104.  
  1105. /*
  1106. ==============
  1107. Load32BitImage
  1108.  
  1109. Any of the return pointers can be NULL if you don't want them.
  1110. ==============
  1111. */
  1112. void Load32BitImage (const char *name, unsigned **pixels,  int *width, int *height)
  1113. {
  1114.     char    ext[128];
  1115.     byte    *palette;
  1116.     byte    *pixels8;
  1117.     byte    *pixels32;
  1118.     int        size;
  1119.     int        i;
  1120.     int        v;
  1121.  
  1122.     ExtractFileExtension (name, ext);
  1123.     if (!Q_stricmp (ext, "tga")) {
  1124.         LoadTGA (name, (byte **)pixels, width, height);
  1125.     } else {
  1126.         Load256Image (name, &pixels8, &palette, width, height);
  1127.         if (!pixels) {
  1128.             return;
  1129.         }
  1130.         size = *width * *height;
  1131.         pixels32 = malloc(size * 4);
  1132.         *pixels = (unsigned *)pixels32;
  1133.         for (i = 0 ; i < size ; i++) {
  1134.             v = pixels8[i];
  1135.             pixels32[i*4 + 0] = palette[ v * 3 + 0 ];
  1136.             pixels32[i*4 + 1] = palette[ v * 3 + 1 ];
  1137.             pixels32[i*4 + 2] = palette[ v * 3 + 2 ];
  1138.             pixels32[i*4 + 3] = 0xff;
  1139.         }
  1140.     }
  1141. }
  1142.  
  1143.  
  1144.